import random
import Grid2D
from Grid2D import *

COLOR_ARVORE = (0,255,0)
COLOR_FOGO = (255,0,0)
COLOR_CLAREIRA = (126,62,0)
COLOR_FOGO_IMINENTE = (255,255,0)
COLOR_AGUA = (0,0,255)
COLOR_FUNDO = (0,0,0)
TIPO_ARVORE = 1
TIPO_CLAREIRA = 2
TIPO_AGUA = 3

class SimFloresta(Grid2D):
    def __init__(self,SCREEN,grid_size,f=0.0001,g=0.01,r=0.02):
        Grid2D.__init__(self, SCREEN, grid_size,g)
        self.SCREEN = SCREEN
        self.SCREEN.fill(COLOR_FUNDO)
        
        self.f = f
        self.r = r
        self.gGlobal = g
        self.aprendizagemActiva = True
        self.setArvores = set()
        self.setClareiras = set()
        self.setFogos = set()
        self.setFogosIminentes = set()
        self.setAgua = set()
        self.setGrid = set(self.getGrid().values())
        self.lenPFerteis = grid_size[X]*grid_size[Y]*1.0
    
    def setgGlobal(self,g):
        for p in self.setGrid:
            p.setG(g)
    
    def flipAprendizagem(self):
        self.aprendizagemActiva = not self.aprendizagemActiva
    
    def getAprendizagemStatus(self):
        return self.aprendizagemActiva
    
    def setupInit(self,prob):
        for p in self.grid.itervalues():
            if random.randint(1,100) <= prob:
                self.setArvores.add(p)
                p.desenhar(COLOR_ARVORE)
            else:
                self.setClareiras.add(p)
                p.desenhar(COLOR_CLAREIRA)
    
    def updateStatesPrimavera(self):
        #----Primavera----
        #Regeneracao de arvores
        for p in self.setClareiras.copy():
            if p.gerarArvore():
                self.setArvores.add(p)
                self.setClareiras.remove(p)
                p.desenhar(COLOR_ARVORE) 
                
            
    def updateStatesVerao(self):     
        #----Verao----
        #Fogos naturais - Arvores ficam em estado de FOGO_EMINENTE
        for p in self.setArvores.copy():
            if p.gerarFogoNatural(self.f):
                self.setFogosIminentes.add(p)
                self.setArvores.remove(p)
        
        #Propagacao de Fogos - Apenas propaga se ESTADO_FOGO e passa a ESTADO_CLAREIRA
        setAprendNegativa = set()
        for p in self.setFogos:
            setVizinhos = p.getNeigh8()
            self.setClareiras.add(p)
            setAprendNegativa.update(setVizinhos)
            p.desenhar(COLOR_CLAREIRA)
            for v in self.setArvores.intersection(setVizinhos):
                if v.gerarFogoPropagado(self.r):
                    self.setFogosIminentes.add(v)
                    self.setArvores.remove(v)
        self.setFogos.clear()  
        
        #Passar de ESTADO_FOGO_EMINENTE para ESTADO_FOGO
        for p in self.setFogosIminentes:
            p.desenhar(COLOR_FOGO)
        self.setFogos = self.setFogosIminentes.copy()
        self.setFogosIminentes.clear()
            
        #Aprender 1v
        if self.aprendizagemActiva:
            for p in setAprendNegativa:
                p.aprender(0.8)
            for p in self.setGrid.difference(setAprendNegativa):
                p.aprender(1.05)
          
        #Retornar densidade
         
        return len(self.setArvores) / self.lenPFerteis
               
        
    '''def flipPatch(self,coord):
        p = self.getPatch(coord)
        if p in self.setArvores:
            self.setArvores.remove(p)
            self.setClareiras.add(p)
            p.desenhar(COLOR_CLAREIRA)
        elif p in self.setClareiras:
            self.setArvores.add(p)
            self.setClareiras.remove(p)
            p.desenhar(COLOR_ARVORE)'''
            
    def setPatch(self,coord,tipo):
        p = self.getPatch(coord)
        if tipo == TIPO_ARVORE:
            self.setClareiras.discard(p)
            self.setAgua.discard(p)
            self.setFogos.discard(p)
            self.setArvores.add(p)
            p.desenhar(COLOR_ARVORE)
        elif tipo == TIPO_CLAREIRA:
            self.setArvores.discard(p)
            self.setAgua.discard(p)
            self.setFogos.discard(p)
            self.setClareiras.add(p)
            p.desenhar(COLOR_CLAREIRA)
        elif tipo == TIPO_AGUA:
            self.setClareiras.discard(p)
            self.setArvores.discard(p)
            self.setFogos.discard(p)
            self.setAgua.add(p)
            p.desenhar(COLOR_AGUA)
        
    def SetWaterGrid(self,wtX,wtY):
        self.setClareiras.update(self.setAgua)
        self.setAgua.clear()
        if wtX>1 and wtY>1:
            for r in range(0,self.grid_size[X],wtX):
                for c in range(0,self.grid_size[Y]):
                    self.setPatch((r,c), TIPO_AGUA)
            for c in range(0,self.grid_size[Y],wtY):
                for r in range(0,self.grid_size[X]):
                    self.setPatch((r,c), TIPO_AGUA)
        self.refreshScreen()
        
            
    
    def refreshScreen(self):
        self.SCREEN.fill(COLOR_FUNDO)
        for p in self.setArvores:
            p.desenhar(COLOR_ARVORE)
        for p in self.setClareiras:
            p.desenhar(COLOR_CLAREIRA)
        for p in self.setFogos:
            p.desenhar(COLOR_FOGO)
        for p in self.setAgua:
            p.desenhar(COLOR_AGUA)
    
            
    
            